import java.util.*;
import java.io.*;


class Read {
    StringTokenizer st = new StringTokenizer("");
    BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
    String next() throws IOException {
        while(!st.hasMoreTokens()) {
            st = new StringTokenizer(bf.readLine());
        }
        return st.nextToken();
    }
    String nextLine() throws IOException {
        return bf.readLine();
    }
    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }
    long nextLong() throws IOException {
        return Long.parseLong(next());
    }
    double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }
}

public class day2 {
    /**
     * 动态规划 + 同余定理
     * DP40 小红取数
     * https://www.nowcoder.com/practice/6a7b2b6c9e3a4f56b1db9f8ca08d889b?tpId=230&tqId=38958&ru=/exam/oj
     */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();
        long[] a = new long[n + 1];
        for(int i = 1;i <= n;i++) {
            a[i] = in.nextLong();
        }

        // dp[i][j]: 表示从前i个数中挑选，总和 %k 之后 余数为j的时，最大的总和
        long[][] dp = new long[n + 1][k];
        // 初始化：将所有值进行初始化为一个负无穷
        for(int i = 0;i <= n;i++) {
            for(int j = 0;j < k;j++){
                dp[i][j] = (long)-1e16;
            }
        }
        dp[0][0] = 0;

        for(int i = 1;i <= n;i++) {
            for(int j = 0;j < k;j++) {
                // 01背包问题，选或不选的最大值
                // 选择i位置的值之后，得到对应的数据是 a[i] % k
                // j - a[i] % (long)k -> 选择i位置的值之后，再i之前查找j-a[i] %k 的值
                // 因为可能出现负数，所以进行+k，也就是余上的数，这样就可以进行纠正 -> j - a[i] % k + k
                // 因为可能出现正数，所以在这个基础上整体进行 %k，这样就可以进行还原原来的正数 j - a[i] % k + k) % k
                dp[i][j] = Math.max(dp[i - 1][j],dp[i - 1][(int)((j - a[i] % (long)k + (long)k) % (long)k)] + a[i]);
            }
        }
        // 因为是%k 为j的最大值，那么想要k的倍数的值，就需要%k之后j为0
        if(dp[n][0] > 0) {
            System.out.println(dp[n][0]);
        }else {
            System.out.println(-1);
        }
    }



    /**
     * 找规律 模拟
     * dd爱旋转
     * https://ac.nowcoder.com/acm/problem/221786
     */
    public static PrintWriter out =
            new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    public static Read in = new Read();

    public static int n;
    public static int[][] arr = new int[1001][1001];

    public static void main2(String[] args) throws IOException {
        n = in.nextInt();
        for(int i = 0;i < n;i++) {
            for(int j = 0;j < n;j++) {
                arr[i][j] = in.nextInt();
            }
        }
        int q = in.nextInt();
        int row = 0;
        int col = 0;
        while(q-- != 0) {
            // 统计一个多少次行操作，列操作
            int x = in.nextInt();
            if(x == 1) {
                // 旋转180，就是将矩阵进行 行镜像1次，列镜像1次
                row++;
                col++;
            }else {
                row++;
            }
        }

        // 优化，不管是行，还是列操作，偶数次进行抵消
        row %= 2;
        col %= 2;

        if(row != 0) {
            setRow();
        }
        if(col != 0) {
            setCol();
        }

        // 交换之后，进行输出
        for(int i = 0;i < n;i++) {
            for(int j = 0;j < n;j++) {
                out.print(arr[i][j] + " ");
            }
            out.println("");
        }
        out.close();
    }

    public static void setRow() {
        // 行镜像
        for(int i = 0;i < n / 2;i++) {
            // 行只会操作 n/2 次，因为每次操作的都是两行
            for(int j = 0;j < n;j++) {
                // 将：arr[i][j] 和 arr[n - 1 - i][j]位置进行交换
                int tmp = arr[i][j];
                arr[i][j] = arr[n - 1 - i][j];
                arr[n - 1 - i][j] = tmp;
            }
        }
    }

    public static void setCol() {
        // 列镜像
        for(int j = 0;j < n / 2;j++) {
            // 列只会操作 n/2 次，因为每次操作的都是两列
            for(int i = 0;i < n;i++) {
                // 将：arr[i][j] 和 arr[i][n - 1 - j]位置进行交换
                int tmp = arr[i][j];
                arr[i][j] = arr[i][n - 1 - j];
                arr[i][n - 1 - j] = tmp;
            }
        }
    }



    /**
     * 预处理(相当于是动态规划中的状态转移方程)
     * 天使果冻
     * https://ac.nowcoder.com/acm/problem/219641
     */
    public static void main1(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] arr = new int[n];
        for(int i = 0;i < n;i++) {
            arr[i] = in.nextInt();
        }

        // 如果想要知道第二大的值，那么需要知道最大的值是多少才能知道第二大值

        int[] f = new int[n + 1]; //f[i]: 表示前i个数中最大的值
        int[] g = new int[n + 1]; //g[i]: 表示前i个数中第二大的值
        // 初始化：
        f[1] = arr[0];
        for(int i = 2;i <= n;i++) {
            int x = arr[i - 1];
            f[i] = Math.max(f[i - 1],x);
            if(x >= f[i - 1]) {
                g[i] = f[i - 1];
            }else if(x >= g[i - 1] && x < f[i - 1]) {
                g[i] = x;
            }else {
                g[i] = g[i - 1];
            }
        }

        int q = in.nextInt();
        while(q-- != 0) {
            int x = in.nextInt();
            System.out.println(g[x]);
        }
    }
}
